#include "financial_income_analytics.h"
#include "ui_financial_income_analytics.h"
#include "api.h"
#include <QStandardItemModel>
#include <QStandardItem>
#include <QHeaderView>
#include <QMessageBox>
#include <QDateTime>
#include <QDate>
#include <QHeaderView>
#include <QIcon>
#include <QTableWidgetItem>
#include <QDebug>
#include <QLabel>
#include <QVBoxLayout>
#include <QRandomGenerator>
#include <QGraphicsOpacityEffect>
#include <QEasingCurve>
#include <QFileDialog>
#include <QFile>
#include <QTextStream>

financial_income_analytics::financial_income_analytics(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::financial_income_analytics),
    m_realtimeChart(nullptr)
{
    ui->setupUi(this);
    
    // 获取API单例实例
    api = Api::getInstance();
    
    setupUI();
    setupConnections();
    
    // 初始化显示实时监控页面
    ui->stackedWidget->setCurrentIndex(0);
    
    // 设置日期控件默认值
    ui->startDateEdit->setDate(QDate::currentDate().addMonths(-3));
    ui->endDateEdit->setDate(QDate::currentDate());

    
    // 初始化实时图表
    setupRealtimeChart();
    
    // 初始化数据展示
    updateRealtimeMetrics();
}

financial_income_analytics::~financial_income_analytics()
{
    if (m_realtimeChart) {
        delete m_realtimeChart;
        m_realtimeChart = nullptr;
    }
    delete ui;
}

void financial_income_analytics::setupUI()
{
    // 设置窗口标题和图标
    setWindowTitle("收入统计与分析模块");
    setWindowIcon(QIcon(":/icons/income_analytics.png"));
    
    // 设置初始选中状态
    setActiveTabButton(ui->realtimeTabBtn);
}


void financial_income_analytics::setupConnections()
{
    // Tab切换连接
    connect(ui->realtimeTabBtn, &QPushButton::clicked, this, &financial_income_analytics::on_realtimeTabBtn_clicked);
    connect(ui->sourceTabBtn, &QPushButton::clicked, this, &financial_income_analytics::on_sourceTabBtn_clicked);
    connect(ui->trendTabBtn, &QPushButton::clicked, this, &financial_income_analytics::on_trendTabBtn_clicked);
    
    // 功能按钮连接
    connect(ui->refreshBtn, &QPushButton::clicked, this, &financial_income_analytics::on_refreshBtn_clicked);
    connect(ui->exportBtn, &QPushButton::clicked, this, &financial_income_analytics::on_exportBtn_clicked);
    connect(ui->analyzeBtn, &QPushButton::clicked, this, &financial_income_analytics::on_analyzeBtn_clicked);
    connect(ui->generateTrendBtn, &QPushButton::clicked, this, &financial_income_analytics::on_generateTrendBtn_clicked);
    
    // 维度切换连接 - 关键修复：添加维度选择变化的信号连接

    connect(ui->dimensionComboBox, &QComboBox::currentIndexChanged, this, &financial_income_analytics::updateSourceAnalysis);

}


// 变化率计算函数：[(当前值-历史值)/历史值]×100%
double financial_income_analytics::calculateChangeRate(double currentValue, double previousValue) {
    // 数据有效性验证
    if (!isValidIncomeData(currentValue) || !isValidIncomeData(previousValue)) {
        return 0.0; // 无效数据返回0
    }
    
    // 避免除零错误
    if (qFabs(previousValue) < 0.01) {
        // 如果历史值接近0，判断当前值是否也为0
        if (qFabs(currentValue) < 0.01) {
            return 0.0; // 两个值都接近0，变化率为0
        } else {
            return currentValue > 0 ? 999.9 : -999.9; // 历史值为0但当前值不为0，返回极值
        }
    }
    
    // 计算变化率：[(当前值-历史值)/历史值]×100%
    double changeRate = ((currentValue - previousValue) / previousValue) * 100.0;
    
    // 限制变化率范围，避免极端值
    if (changeRate > 999.9) changeRate = 999.9;
    if (changeRate < -999.9) changeRate = -999.9;
    
    return changeRate;
}

// 收入数据有效性验证
bool financial_income_analytics::isValidIncomeData(double value) {
    // 检查是否为有效数值
    if (qIsNaN(value) || qIsInf(value)) {
        return false;
    }
    
    // 检查是否为负数（收入不应该为负）
    if (value < 0) {
        return false;
    }
    
    // 检查是否超出合理范围（假设单日收入不超过1000万）
    if (value > 10000000.0) {
        return false;
    }
    
    return true;
}

// 数据验证和计算函数
void financial_income_analytics::validateAndCalculateMetrics(const QJsonObject &data, 
                                                           double &dailyChange, double &monthlyChange, 
                                                           double &yearlyChange, double &realtimeChange) {
    // 获取原始数据
    double todayIncome = data["todayIncome"].toString().toDouble();
    double yesterdayIncome = data["yesterdayIncome"].toString().toDouble();
    double thisMonthIncome = data["thisMonthIncome"].toString().toDouble();
    double lastMonthIncome = data["lastMonthIncome"].toString().toDouble();
    double thisYearIncome = data["thisYearIncome"].toString().toDouble();
    double lastYearIncome = data["lastYearIncome"].toString().toDouble();
    double thisHourIncome = data["thisHourIncome"].toString().toDouble();
    double lastHourIncome = data["lastHourIncome"].toString().toDouble();
    
    // 验证数据有效性并重新计算变化率
    if (!isValidIncomeData(todayIncome) || !isValidIncomeData(yesterdayIncome)) {
        dailyChange = 0.0;
        qWarning() << "日收入数据无效，使用默认变化率0";
    }
    
    if (!isValidIncomeData(thisMonthIncome) || !isValidIncomeData(lastMonthIncome)) {
        monthlyChange = 0.0;
        qWarning() << "月收入数据无效，使用默认变化率0";
    }
    
    if (!isValidIncomeData(thisYearIncome) || !isValidIncomeData(lastYearIncome)) {
        yearlyChange = 0.0;
        qWarning() << "年收入数据无效，使用默认变化率0";
    }
    
    if (!isValidIncomeData(thisHourIncome) || !isValidIncomeData(lastHourIncome)) {
        realtimeChange = 0.0;
        qWarning() << "小时收入数据无效，使用默认变化率0";
    }
    
    // 记录验证后的数据用于调试
    qDebug() << "数据验证完成 - 今日收入:" << todayIncome << "昨日收入:" << yesterdayIncome 
             << "月收入:" << thisMonthIncome << "上月收入:" << lastMonthIncome
             << "年收入:" << thisYearIncome << "上年收入:" << lastYearIncome
             << "小时收入:" << thisHourIncome << "上小时收入:" << lastHourIncome;
}

// Tab切换槽函数实现
void financial_income_analytics::on_realtimeTabBtn_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
    setActiveTabButton(ui->realtimeTabBtn);
    updateRealtimeMetrics();
}

void financial_income_analytics::on_sourceTabBtn_clicked()
{
    try {
        // 空指针检查
        if (!ui) {
            qDebug() << "UI未初始化，无法切换到收入来源分析页面";
            return;
        }
        
        // stackedWidget安全检查
        if (!ui->stackedWidget) {
            qDebug() << "stackedWidget未初始化";
            return;
        }
        
        // 切换到收入来源分析页面
        ui->stackedWidget->setCurrentIndex(1);
        
        // 设置活动标签按钮 - 带安全检查
        if (ui->sourceTabBtn) {
            setActiveTabButton(ui->sourceTabBtn);
        }
        
        // 刷新数据
        updateSourceAnalysis();
    } catch (const std::exception& e) {
        qDebug() << "切换到收入来源分析页面时发生异常:" << e.what();
        if (ui) {
            showErrorState("页面切换失败: " + QString::fromStdString(e.what()));
        }
    } catch (...) {
        qDebug() << "切换到收入来源分析页面时发生未知异常";
        if (ui) {
            showErrorState("页面切换失败，请重试");
        }
    }
}

void financial_income_analytics::on_trendTabBtn_clicked()
{
    ui->stackedWidget->setCurrentIndex(2);
    setActiveTabButton(ui->trendTabBtn);
    updateTrendAnalysis();
}



// 功能按钮槽函数实现
void financial_income_analytics::on_refreshBtn_clicked()
{
    // 显示加载状态
    showLoadingState();
    
    // 根据当前显示的页面刷新相应的数据
    try {
        // UI有效性检查
        if (!ui || !ui->stackedWidget) {
            qDebug() << "错误: UI对象或stackedWidget为空，无法刷新数据";
            showErrorState("系统初始化错误");
            return;
        }
        
        // 获取当前页面索引
        int currentPageIndex = ui->stackedWidget->currentIndex();
        
        qDebug() << "刷新数据，当前页面索引:" << currentPageIndex;
        
        // 根据不同页面调用相应的更新函数
        switch (currentPageIndex) {
        case 0: // 实时监控页面
            updateRealtimeMetrics();
            break;
        case 1: // 收入来源页面
            updateSourceAnalysis();
            break;
        case 2: // 趋势分析页面
            updateTrendAnalysis();
            break;
        default:
            qWarning() << "未知页面索引:" << currentPageIndex;
            // 默认刷新实时监控页面数据
            updateRealtimeMetrics();
            break;
        }
    } catch (const std::exception& e) {
        qDebug() << "刷新数据时发生异常:" << e.what();
        showErrorState("数据刷新异常");
    } catch (...) {
        qDebug() << "刷新数据时发生未知异常";
        showErrorState("未知异常");
    }
}

void financial_income_analytics::on_exportBtn_clicked()
{
    try {
        // 获取当前页面索引
        int currentPageIndex = ui->stackedWidget->currentIndex();
        QString pageName;
        QString exportFileName;
        QByteArray fileContent;

        // 设置页面名称
        switch (currentPageIndex) {
        case 0: // 实时监控页面
            pageName = "实时监控";
            break;
        case 1: // 收入来源页面
            pageName = "收入来源";
            break;
        case 2: // 趋势分析页面
            pageName = "趋势分析";
            break;
        default:
            pageName = "数据报表";
            break;
        }

        qDebug() << "导出报表，当前页面:" << pageName;

        // 添加文件保存对话框和格式选择
        QString fileName = QFileDialog::getSaveFileName(this, 
                                                        "导出报表",
                                                        QString("收入分析报表_%1_%2").arg(pageName)
                                                                                     .arg(QDateTime::currentDateTime().toString("yyyyMMdd_HHmmss")),
                                                        "CSV文件 (*.csv);;文本文件 (*.txt);;所有文件 (*)");

        if (fileName.isEmpty()) {
            qDebug() << "用户取消了导出操作";
            return;
        }

        // 根据当前页面准备导出数据
        QString exportData = prepareExportData(currentPageIndex);

        // 保存文件
        QFile file(fileName);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
            QMessageBox::critical(this, "导出失败", "无法创建文件：" + fileName);
            qDebug() << "无法创建文件:" << fileName << file.errorString();
            return;
        }

        QTextStream out(&file);
        out << exportData;
        file.close();

        // 导出成功提示
        QMessageBox::information(this, "导出成功", "报表已成功导出至：\n" + fileName);
        qDebug() << "报表导出成功:" << fileName;

    } catch (const std::exception& e) {
        qDebug() << "导出报表时发生异常:" << e.what();
        QMessageBox::critical(this, "导出失败", "导出过程中发生错误，请重试。");
    } catch (...) {
        qDebug() << "导出报表时发生未知异常";
        QMessageBox::critical(this, "导出失败", "导出过程中发生未知错误，请重试。");
    }
}

QString financial_income_analytics::prepareExportData(int pageIndex)
{    QString data;
    QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss");
    
    // 添加报表头部信息
    data += "===== 收入分析系统 - 数据报表 =====\n";
    data += "导出时间: " + currentTime + "\n\n";

    switch (pageIndex) {
    case 0: { // 实时监控页面
        data += "报表类型: 实时监控数据\n\n";
        data += "收入指标,当前值,日环比,月环比,同比\n";
        
        // 使用正确的UI控件名称并添加空指针检查
        QString dailyIncome = ui->dailyIncomeValue ? ui->dailyIncomeValue->text().remove("¥").replace(",", "") : "0";
        QString dailyChange = ui->dailyIncomeChange ? ui->dailyIncomeChange->text().remove("▲").remove("▼").remove("%").trimmed() : "0";
        QString monthlyChange = ui->monthlyIncomeChange ? ui->monthlyIncomeChange->text().remove("▲").remove("▼").remove("%").trimmed() : "0";
        QString yearlyChange = ui->yearlyIncomeChange ? ui->yearlyIncomeChange->text().remove("▲").remove("▼").remove("%").trimmed() : "0";
        
        data += "实时收入," + dailyIncome + "," + dailyChange + "," + monthlyChange + "," + yearlyChange + "\n";
        break;
    }
        
    case 1: { // 收入来源页面
        data += "报表类型: 收入来源分析\n\n";
        data += "收入来源,金额,占比\n";
        
        // 查找名称为sourceAnalysisTable的QTableView
        QTableView* tableView = nullptr;
        QList<QTableView*> tableViews = ui->barChartFrame->findChildren<QTableView*>("sourceAnalysisTable");
        if (!tableViews.isEmpty()) {
            tableView = tableViews.first();
            
            QStandardItemModel* model = qobject_cast<QStandardItemModel*>(tableView->model());
            if (model && model->rowCount() > 0) {
                for (int row = 0; row < model->rowCount(); ++row) {
                    for (int col = 0; col < model->columnCount(); ++col) {
                        QStandardItem* item = model->item(row, col);
                        if (item) {
                            data += item->text();
                        }
                        if (col < model->columnCount() - 1) {
                            data += ",";
                        }
                    }
                    data += "\n";
                }
            } else {
                data += "暂无数据\n";
            }
        } else {
            data += "表格未加载\n";
        }
        break;
    }
        
    case 2: { // 趋势分析页面
        data += "报表类型: 收入趋势分析\n\n";
        data += "时间点,收入金额\n";
        data += "最近7天趋势数据（模拟）\n";
        for (int i = 6; i >= 0; --i) {
            QDate date = QDate::currentDate().addDays(-i);
            // 使用整数范围然后转换为浮点数，避免bounded方法的歧义调用
            int minValue = 50000;
            int maxValue = 200000;
            double value = minValue + QRandomGenerator::global()->bounded(maxValue - minValue + 1);
            data += date.toString("yyyy-MM-dd") + "," + QString::number(value, 'f', 2) + "\n";
        }
        break;
    }
        
    default:
        data += "报表类型: 综合数据\n\n";
        data += "导出了默认报表数据\n";
        break;
    }

    return data;
}

void financial_income_analytics::on_analyzeBtn_clicked()
{
    QMessageBox::information(this, "收入来源分析", "正在生成收入来源分析报告...\n\n"
        "分析维度：" + ui->dimensionComboBox->currentText() + "\n\n"
        "分析内容：\n"
        "• 各收入来源占比分析\n"
        "• 收入增长趋势对比\n"
        "• 利润率计算分析\n"
        "• 同比环比数据对比");
}

void financial_income_analytics::on_generateTrendBtn_clicked()
{
    QMessageBox::information(this, "趋势分析", "正在生成收入趋势分析...\n\n"
        "分析周期：" + ui->periodComboBox->currentText() + "\n"
        "时间范围：" + ui->startDateEdit->date().toString("yyyy-MM-dd") + " 至 " + 
        ui->endDateEdit->date().toString("yyyy-MM-dd") + "\n\n"
        "分析指标：\n"
        "• 同比增长率 (YoY)\n"
        "• 环比增长率 (MoM)\n"
        "• 复合年增长率 (CAGR)\n"
        "• 季节性趋势分析");
}



// 数据展示方法实现
void financial_income_analytics::updateRealtimeMetrics()
{
    // 显示加载状态
    showLoadingState();
    
    try {
        // UI有效性检查
        if (!ui) {
            qDebug() << "错误: UI对象为空，无法更新实时指标";
            showErrorState("系统初始化错误");
            return;
        }
        
        // 使用API获取收入统计数据
        api->getIncomeStatistics([this](bool success, const QJsonObject& response, const QString& errorMsg, int /*statusCode*/) {
            try {
                // 再次检查UI指针有效性（在回调中）
                if (!ui) {
                    qDebug() << "错误: 回调中UI对象为空";
                    return;
                }
                
                if (success) {
                    // 重置样式为正常状态
                    QString normalStyle = "color: #202124; font-weight: normal;";
                    
                    // 空指针安全检查
                    if (ui->dailyIncomeValue) ui->dailyIncomeValue->setStyleSheet(normalStyle);
                    if (ui->monthlyIncomeValue) ui->monthlyIncomeValue->setStyleSheet(normalStyle);
                    if (ui->yearlyIncomeValue) ui->yearlyIncomeValue->setStyleSheet(normalStyle);

                    // 从API响应中获取原始收入数据
                    double todayIncome = response["todayIncome"].toString().toDouble();
                    double yesterdayIncome = response["yesterdayIncome"].toString().toDouble();
                    double thisMonthIncome = response["thisMonthIncome"].toString().toDouble();
                    double lastMonthIncome = response["lastMonthIncome"].toString().toDouble();
                    double thisYearIncome = response["thisYearIncome"].toString().toDouble();
                    double lastYearIncome = response["lastYearIncome"].toString().toDouble();
                    double thisHourIncome = response["thisHourIncome"].toString().toDouble();
                    double lastHourIncome = response["lastHourIncome"].toString().toDouble();
                    
                    // 手动计算变化率
                    double dailyChange = calculateChangeRate(todayIncome, yesterdayIncome);
                    double monthlyChange = calculateChangeRate(thisMonthIncome, lastMonthIncome);
                    double yearlyChange = calculateChangeRate(thisYearIncome, lastYearIncome);
                    double realtimeChange = calculateChangeRate(thisHourIncome, lastHourIncome);
                    
                    // 更新UI显示（带安全检查）
                    if (ui->dailyIncomeValue) setMetricValue(ui->dailyIncomeValue, todayIncome);
                    if (ui->monthlyIncomeValue) setMetricValue(ui->monthlyIncomeValue, thisMonthIncome);
                    if (ui->yearlyIncomeValue) setMetricValue(ui->yearlyIncomeValue, thisYearIncome);
                    
                    // 设置变化率显示（带安全检查）
                    if (ui->dailyIncomeChange) setChangeValue(ui->dailyIncomeChange, dailyChange);
                    if (ui->monthlyIncomeChange) setChangeValue(ui->monthlyIncomeChange, monthlyChange);
                    if (ui->yearlyIncomeChange) setChangeValue(ui->yearlyIncomeChange, yearlyChange);
                    
                    // 设置实时增长率（带安全检查）
                    if (ui->growthRateValue) {
                        if (realtimeChange >= 0) {
                            ui->growthRateValue->setText("▲ " + QString::number(realtimeChange, 'f', 1) + "%");
                            ui->growthRateValue->setStyleSheet("color: #188038; font-weight: bold;");
                        } else {
                            ui->growthRateValue->setText("▼ " + QString::number(qAbs(realtimeChange), 'f', 1) + "%");
                            ui->growthRateValue->setStyleSheet("color: #d93025; font-weight: bold;");
                        }
                    }
                    
                    // 更新时间显示（带安全检查）
                    if (ui->updateTimeLabel) {
                        if (response.contains("updateTime")) {
                            ui->updateTimeLabel->setText("更新时间: " + response["updateTime"].toString());
                        } else {
                            ui->updateTimeLabel->setText("更新时间: " + QDateTime::currentDateTime().toString("hh:mm:ss"));
                        }
                        
                        // 检查是否使用了模拟数据
                        if (response.contains("message") && response["message"].toString().contains("模拟数据")) {
                            ui->updateTimeLabel->setText(ui->updateTimeLabel->text() + " (使用模拟数据)");
                        }
                    }
                    
                    // 更新图表数据 - 使用API返回的24小时数据
                    if (response.contains("last24HoursData") && response["last24HoursData"].isArray()) {
                        QJsonArray hourlyData = response["last24HoursData"].toArray();
                        QStringList labels;
                        QList<double> values;
                        
                        for (const auto& item : hourlyData) {
                            QJsonObject hourData = item.toObject();
                            labels << hourData["hour"].toString();
                            values << hourData["income"].toString().toDouble();
                        }
                        
                        updateRealtimeChart(labels, values);
                        qDebug() << "使用API返回的24小时数据更新图表，数据点数量:" << values.size();
                    }
                    
                    qDebug() << "收入统计数据更新成功 - 基于原始数据手动计算变化率";
                    qDebug() << "日变化率:" << dailyChange << "% 月变化率:" << monthlyChange << "% 年变化率:" << yearlyChange << "% 实时变化率:" << realtimeChange << "%";
                } else {
                    // 数据获取失败，显示错误状态但不关闭窗口
                    QString displayError = errorMsg.isEmpty() ? "数据加载失败" : errorMsg;
                    showErrorState(displayError);
                    qDebug() << "收入统计数据获取失败:" << errorMsg;
                    
                    // 确保窗口保持显示
                    if (!isVisible()) {
                        show();
                    }
                }
            } catch (const std::exception& e) {
                qDebug() << "Exception in updateRealtimeMetrics callback:" << e.what();
                showErrorState("数据处理异常");
                // 确保窗口保持显示
                if (!isVisible()) {
                    show();
                }
            } catch (...) {
                qDebug() << "Unknown exception in updateRealtimeMetrics callback";
                showErrorState("未知异常");
                // 确保窗口保持显示
                if (!isVisible()) {
                    show();
                }
            }
        });
    } catch (const std::exception& e) {
        qDebug() << "Exception in updateRealtimeMetrics:" << e.what();
        showErrorState("请求异常");
        // 确保窗口保持显示
        if (!isVisible()) {
            show();
        }
    } catch (...) {
        qDebug() << "Unknown exception in updateRealtimeMetrics";
        showErrorState("未知异常");
        // 确保窗口保持显示
        if (!isVisible()) {
            show();
        }
    }
}

void financial_income_analytics::updateSourceAnalysis()
{
    try {
        // 空指针检查
        if (!ui || !api) {
            qDebug() << "UI组件或API对象未初始化，无法获取收入来源分析数据";
            if (ui) {
                showErrorState("系统初始化错误");
            }
            return;
        }
        
        // 获取选中的维度 - 增加安全检查
        if (!ui->dimensionComboBox) {
            qDebug() << "维度选择组件未初始化";
            showErrorState("UI组件错误");
            return;
        }
        
        QString dimension = ui->dimensionComboBox->currentText();
        
        // 参数验证
        if (dimension.isEmpty()) {
            qDebug() << "维度参数为空，使用默认值";
            dimension = "车次类型"; // 设置默认值
        }
        
        // 显示加载状态
        showLoadingState();
        
        // 构建请求参数
        QJsonObject params;
        
        // 调用API获取数据 - 使用智能指针和错误恢复机制
        api->getSourceAnalysisData(dimension, params, [this](bool success, const QJsonObject& response, const QString& errorMsg, int statusCode) {
            try {
                // 检查UI是否已销毁
                if (!ui) {
                    qDebug() << "UI已销毁，跳过数据处理";
                    return;
                }
                
                if (success) {
                    // 数据有效性检查
                    if (!response.contains("data") || !response["data"].isObject()) {
                        qDebug() << "响应数据格式错误，缺少data字段";
                        showErrorState("数据格式错误");
                        return;
                    }
                    
                    QJsonObject data = response["data"].toObject();
                    
                    // 检查sourceData字段
                    if (!data.contains("sourceData") || !data["sourceData"].isArray()) {
                        qDebug() << "数据缺少sourceData数组";
                        showErrorState("数据结构错误");
                        return;
                    }
                    
                    QJsonArray sourceData = data["sourceData"].toArray();
                    
                    qDebug() << "成功获取收入来源分析数据，共" << sourceData.size() << "条记录";
                    
                    // 更新表格数据 - 这里会进行UI检查
                    updateBarChartTable(sourceData);
                    
                    // 更新最后更新时间 - 修复缺失的UI更新
                    if (ui->updateTimeLabel) {
                        ui->updateTimeLabel->setText("更新时间: " + QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
                    }
                    
                    qDebug() << "收入来源分析数据更新完成";
                } else {
                    QString errorDetail = QString("获取收入来源分析数据失败: %1 (状态码: %2)").arg(errorMsg).arg(statusCode);
                    qDebug() << errorDetail;
                    
                    // 显示错误状态
                    showErrorState(errorMsg.isEmpty() ? "数据获取失败，请稍后重试" : errorMsg);
                }
            } catch (const std::exception& e) {
                qDebug() << "处理收入来源分析数据时发生异常:" << e.what();
                if (ui) {
                    showErrorState("数据处理错误: " + QString::fromStdString(e.what()));
                }
            } catch (...) {
                qDebug() << "处理收入来源分析数据时发生未知异常";
                if (ui) {
                    showErrorState("未知错误，请检查系统日志");
                }
            }
        });
    } catch (const std::exception& e) {
        qDebug() << "更新收入来源分析时发生异常:" << e.what();
        if (ui) {
            showErrorState("系统异常: " + QString::fromStdString(e.what()));
        }
    } catch (...) {
        qDebug() << "更新收入来源分析时发生未知异常";
        if (ui) {
            showErrorState("未知系统错误，请联系管理员");
        }
    }
}

void financial_income_analytics::updateBarChartTable(const QJsonArray& data)
{
    // 空指针检查
    if (!ui || !ui->barChartFrame) {
        qDebug() << "UI组件未初始化，无法更新表格";
        return;
    }
    
    // 清除barChartFrame中的所有子部件（除了标题和布局）
    QLayout* mainLayout = ui->barChartFrame->layout();
    if (mainLayout) {
        // 保存标题标签（如果存在）
        QWidget* titleLabel = nullptr;
        if (ui->barChartTitleLabel) {
            titleLabel = ui->barChartTitleLabel;
        }
        
        // 清除所有子部件
        QLayoutItem* item;
        while ((item = mainLayout->takeAt(0)) != nullptr) {
            QWidget* widget = item->widget();
            if (widget) {
                // 跳过标题标签
                if (widget == titleLabel) {
                    continue;
                }
                // 移除模型关联以避免崩溃
                if (QTableView* tableView = qobject_cast<QTableView*>(widget)) {
                    tableView->setModel(nullptr);
                }
                delete widget;
            }
            delete item;
        }
        
        // 重新添加标题标签
        if (titleLabel && !titleLabel->parentWidget()) {
            mainLayout->addWidget(titleLabel);
        }
    }
    
    // 创建表格视图
    QTableView* tableView = new QTableView(ui->barChartFrame);
    tableView->setObjectName("sourceAnalysisTable");
    tableView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    tableView->setAttribute(Qt::WA_DeleteOnClose); // 确保窗口关闭时删除
    
    // 设置表格模型 - 使用tableView作为父对象，确保正确的生命周期管理
    QStandardItemModel* model = new QStandardItemModel(tableView);
    
    // 设置表头
    QStringList headers;
    headers << "名称" << "收入金额" << "订单数量" << "占比(%)";
    model->setHorizontalHeaderLabels(headers);
    
    // 填充数据 - 添加错误检查
    for (int i = 0; i < data.size(); ++i) {
        if (!data[i].isObject()) {
            qDebug() << "数据项不是有效的JSON对象，跳过:" << i;
            continue;
        }
        
        QJsonObject item = data[i].toObject();
        
        // 检查必要字段是否存在
        if (!item.contains("name") || !item.contains("value") || 
            !item.contains("count") || !item.contains("percentage")) {
            qDebug() << "数据项缺少必要字段，跳过:" << i;
            continue;
        }
        
        QList<QStandardItem*> rowItems;
        
        // 名称
        rowItems << new QStandardItem(item["name"].toString());
        
        // 收入金额（格式化）
        QString incomeStr = QString("¥%1").arg(item["value"].toDouble(), 0, 'f', 2);
        rowItems << new QStandardItem(incomeStr);
        
        // 订单数量
        rowItems << new QStandardItem(QString::number(item["count"].toInt()));
        
        // 占比
        QString percentageStr = QString("%1%").arg(item["percentage"].toDouble(), 0, 'f', 1);
        rowItems << new QStandardItem(percentageStr);
        
        // 设置单元格对齐方式
        for (int j = 0; j < rowItems.size(); ++j) {
            if (rowItems[j]) { // 空指针检查
                if (j == 0) { // 名称左对齐
                    rowItems[j]->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter);
                } else { // 数值右对齐
                    rowItems[j]->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
                }
                rowItems[j]->setEditable(false);
            }
        }
        
        model->appendRow(rowItems);
    }
    
    // 应用表格模型
    tableView->setModel(model);
    
    // 设置表格样式
    tableView->setAlternatingRowColors(true);
    tableView->setStyleSheet("QTableView {"  
                           "alternate-background-color: #f0f0f0;" 
                           "background-color: white;" 
                           "border: 1px solid #d0d0d0;" 
                           "border-radius: 4px;" 
                           "padding: 2px;" 
                           "}"
                           "QHeaderView::section {" 
                           "background-color: #f5f5f5;" 
                           "color: #333333;" 
                           "padding: 8px;" 
                           "border: 1px solid #d0d0d0;" 
                           "text-align: center;" 
                           "font-weight: bold;" 
                           "}");
    
    // 自动调整列宽 - 添加安全检查
    if (tableView->horizontalHeader()) {
        tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    }
    if (tableView->verticalHeader()) {
        tableView->verticalHeader()->setVisible(false); // 隐藏行号
    }
    
    // 添加表格到布局
    if (mainLayout) {
        // 使用现有的布局
        mainLayout->addWidget(tableView);
    } else if (ui->barChartLayout) {
        // 如果有barChartLayout，使用它
        ui->barChartLayout->addWidget(tableView);
    } else {
        // 如果没有布局，创建新布局
        QVBoxLayout* newLayout = new QVBoxLayout(ui->barChartFrame);
        newLayout->setContentsMargins(0, 0, 0, 0);
        
        // 添加标题标签（如果存在）
        if (ui->barChartTitleLabel) {
            newLayout->addWidget(ui->barChartTitleLabel);
        }
        
        newLayout->addWidget(tableView);
    }
    
    // 更新样式
    ui->barChartFrame->setStyleSheet("background-color: white; border: 1px solid #e0e0e0; border-radius: 4px;");
}

void financial_income_analytics::updateTrendAnalysis()
{
    // 显示加载状态
    ui->generateTrendBtn->setDisabled(true);
    QString originalText = ui->generateTrendBtn->text();
    ui->generateTrendBtn->setText("⏳ 加载中...");
    
    // 获取查询参数
    QString periodText = ui->periodComboBox->currentText();
    QDate startDate = ui->startDateEdit->date();
    QDate endDate = ui->endDateEdit->date();
    QString startDateStr = startDate.toString("yyyy-MM-dd");
    QString endDateStr = endDate.toString("yyyy-MM-dd");
    
    // 更新趋势图标题
    ui->trendChartTitleLabel->setText(QString("收入趋势分析 (%1 - %2)").arg(startDateStr).arg(endDateStr));
    
    // 参数验证：验证日期范围
    int daysDiff = startDate.daysTo(endDate);
    bool validRange = false;
    
    if (periodText.contains("日")) {
        validRange = (daysDiff >= 1); // 日度分析至少1天
    } else if (periodText.contains("周")) {
        validRange = (daysDiff >= 7); // 周度分析至少7天
    } else if (periodText.contains("月")) {
        validRange = (daysDiff >= 30); // 月度分析至少30天
    } else if (periodText.contains("年")) {
        validRange = (daysDiff >= 365); // 年度分析至少365天
    }
    
    if (!validRange) {
        // 恢复按钮状态
        ui->generateTrendBtn->setText(originalText);
        ui->generateTrendBtn->setDisabled(false);
        
        QString errorMsg = "日期范围不符合要求：";
        if (periodText.contains("日")) errorMsg += "日度分析需要至少1天";
        else if (periodText.contains("周")) errorMsg += "周度分析需要至少7天";
        else if (periodText.contains("月")) errorMsg += "月度分析需要至少30天";
        else if (periodText.contains("年")) errorMsg += "年度分析需要至少365天";
        
        showErrorState(errorMsg);
        return;
    }
    // 调用API获取每日收入数据
    QJsonObject params;
    params["start_date"] = startDateStr;
    params["end_date"] = endDateStr;
    
    // 恢复按钮状态的辅助函数
    auto restoreButtonState = [this, originalText]() {
        if(originalText.contains("加载")) return;
        if (this && ui && ui->generateTrendBtn) { // 确保所有指针都有效
            qDebug() << "Original text:" << originalText;
            ui->generateTrendBtn->setText(originalText);
            ui->generateTrendBtn->setDisabled(false);
            qDebug() << "Button state restored"; // 添加调试信息
        } else {
            qDebug() << "Warning: Invalid pointers detected in restoreButtonState";
        }
    };

    // 正确的API调用顺序：url, params, timeout, callback
    Api::getInstance()->get("/api/v1/income/trend-analysis", params, 5000, [this, originalText, periodText, startDate, endDate, restoreButtonState](bool success, const QJsonObject& response, const QString& errorMsg, int statusCode) {
        // 确保在主线程中执行UI操作
        QMetaObject::invokeMethod(this, [this, success, response, errorMsg, periodText, startDate, endDate, restoreButtonState]() {
            // 首先恢复按钮状态，确保无论成功失败都能恢复
            restoreButtonState();

            qDebug() << "inin";
            
            // 仅在成功时继续处理数据

            
            try {
                // 添加全面的错误检查
                if (!this || !ui) {
                    qDebug() << "Critical error: Invalid 'this' or 'ui' pointer";
                    return;
                }
                
                // 检查response是否包含有效的data字段
                if (!response.contains("data") || !response["data"].isArray()) {
                    qDebug() << "Warning: Invalid or missing data in API response";
                    showErrorState("API返回的数据格式不正确");
                    return;
                }
                
                // 获取每日收入数据
                QJsonArray dailyData = response["data"].toArray();
                
                if (dailyData.isEmpty()) {
                    qDebug() << "Warning: API returned empty data array";
                    // 即使数据为空，也更新UI以显示零值
                    if (ui->summaryTotalValue) ui->summaryTotalValue->setText("¥0.00");
                    if (ui->summaryAvgValue) ui->summaryAvgValue->setText("¥0.00");
                    return;
                }
                
                // 数据聚合：根据不同时间维度聚合数据
                QMap<QString, double> aggregatedData;
                double totalIncome = 0.0;
                
                for (const QJsonValue& item : dailyData) {
                    // 检查item是否是有效的对象
                    if (!item.isObject()) {
                        qDebug() << "Warning: Invalid item in data array";
                        continue;
                    }
                    
                    QJsonObject record = item.toObject();
                    // 检查必要字段是否存在
                    if (!record.contains("date") || !record.contains("income")) {
                        qDebug() << "Warning: Missing required fields in record";
                        continue;
                    }
                    
                    QString dateStr = record["date"].toString();
                    // 灵活处理income字段，无论它是字符串还是数字
                    double income = 0.0;
                    if (record["income"].isString()) {
                        income = record["income"].toString().toDouble();
                    } else if (record["income"].isDouble()) {
                        income = record["income"].toDouble();
                    }
                    
                    totalIncome += income;
                    
                    // 根据时间维度聚合，添加periodText有效性检查
                    if (!periodText.isEmpty()) {
                        if (periodText.contains("日")) {
                            // 日度分析 - 直接使用日期
                            aggregatedData[dateStr] += income;
                        } else if (periodText.contains("周")) {
                            // 周度分析 - 按周聚合
                            QDate date = QDate::fromString(dateStr, "yyyy-MM-dd");
                            if (date.isValid()) {
                                int weekNumber = date.weekNumber();
                                QString weekKey = QString("%1-W%2").arg(date.year()).arg(weekNumber, 2, 10, QLatin1Char('0'));
                                aggregatedData[weekKey] += income;
                            }
                        } else if (periodText.contains("月")) {
                            // 月度分析 - 按月聚合
                            if (dateStr.length() >= 7) {
                                QString monthKey = dateStr.left(7); // 格式：yyyy-MM
                                aggregatedData[monthKey] += income;
                            }
                        } else if (periodText.contains("年")) {
                            // 年度分析 - 按年聚合
                            if (dateStr.length() >= 4) {
                                QString yearKey = dateStr.left(4); // 格式：yyyy
                                aggregatedData[yearKey] += income;
                            }
                        }
                    }
                }
                
                // 计算平均收入
                double avgIncome = 0.0;
                if (!aggregatedData.isEmpty()) {
                    avgIncome = totalIncome / aggregatedData.size();
                }
                
                // 更新数据统计显示，确保UI组件有效
                if (ui->summaryTotalValue) {
                    setMetricValue(ui->summaryTotalValue, totalIncome, "¥");
                }
                if (ui->summaryAvgValue) {
                    setMetricValue(ui->summaryAvgValue, avgIncome, "¥");
                }
                
                // 准备图表数据
                QStringList labels;
                QList<double> values;
                
                // 按时间顺序排序并准备图表数据
                QMapIterator<QString, double> it(aggregatedData);
                while (it.hasNext()) {
                    it.next();
                    labels << it.key();
                    values << it.value();
                }
                
                // 更新趋势分析图表，确保图表组件有效
                if (ui->trendChartWidget) {
                    // 将QWidget转换为IncomeChartWidget类型
                    IncomeChartWidget *chartWidget = qobject_cast<IncomeChartWidget*>(ui->trendChartWidget);
                    if (chartWidget) {
                        chartWidget->updateChart(labels, values);
                        qDebug() << "Chart updated using trendChartWidget";
                    } else if (m_realtimeChart) {
                        // 如果trendChartWidget不是IncomeChartWidget，则使用m_realtimeChart
                        m_realtimeChart->updateChart(labels, values);
                        qDebug() << "Chart updated using m_realtimeChart";
                    } else {
                        qDebug() << "Warning: No valid chart widget available";
                    }
                }
                // 触发图表区域的淡入动画效果
                QGraphicsOpacityEffect *opacityEffect = new QGraphicsOpacityEffect(ui->trendChartFrame);
                ui->trendChartFrame->setGraphicsEffect(opacityEffect);
                
                QPropertyAnimation *animation = new QPropertyAnimation(opacityEffect, "opacity");
                animation->setDuration(600);
                animation->setStartValue(0.6);
                animation->setEndValue(1.0);
                animation->start(QAbstractAnimation::DeleteWhenStopped);
                
                // 清理动画资源
                connect(animation, &QPropertyAnimation::finished, [opacityEffect]() {
                    opacityEffect->deleteLater();
                });
                qDebug() << "inin";
            } catch (const std::exception& e) {
                qDebug() << "Exception caught during data processing:" << e.what();
                if (this && ui) {
                    showErrorState(QString("数据处理异常: %1").arg(e.what()));
                }
            } catch (...) {
                qDebug() << "Unknown exception caught during data processing";
                if (this && ui) {
                    showErrorState("数据处理时发生未知异常");
                }
            }
        });
    });
}

// metricsFrame removed - 移除了updateMetricValueWithAnimation函数的实现





// 错误处理和状态管理方法实现
void financial_income_analytics::showLoadingState()
{
    // 显示加载状态
    ui->dailyIncomeValue->setText("加载中...");
    ui->monthlyIncomeValue->setText("加载中...");
    ui->yearlyIncomeValue->setText("加载中...");
    ui->growthRateValue->setText("加载中...");
    ui->dailyIncomeChange->setText("加载中...");
    ui->monthlyIncomeChange->setText("加载中...");
    ui->yearlyIncomeChange->setText("加载中...");
    
    // 设置加载状态的样式
    QString loadingStyle = "color: #5f6368; font-style: italic;";
    ui->dailyIncomeValue->setStyleSheet(loadingStyle);
    ui->monthlyIncomeValue->setStyleSheet(loadingStyle);
    ui->yearlyIncomeValue->setStyleSheet(loadingStyle);
    ui->growthRateValue->setStyleSheet(loadingStyle);
    ui->dailyIncomeChange->setStyleSheet(loadingStyle);
    ui->monthlyIncomeChange->setStyleSheet(loadingStyle);
    ui->yearlyIncomeChange->setStyleSheet(loadingStyle);
}

void financial_income_analytics::showErrorState(const QString& errorMessage)
{
    // 显示错误状态
    QString displayError = errorMessage.isEmpty() ? "数据加载失败" : errorMessage;
    
    ui->dailyIncomeValue->setText(displayError);
    ui->monthlyIncomeValue->setText(displayError);
    ui->yearlyIncomeValue->setText(displayError);
    ui->growthRateValue->setText("--");
    ui->dailyIncomeChange->setText("--");
    ui->monthlyIncomeChange->setText("--");
    ui->yearlyIncomeChange->setText("--");
    
    // 设置错误状态的样式
    QString errorStyle = "color: #d93025; font-weight: bold;";
    ui->dailyIncomeValue->setStyleSheet(errorStyle);
    ui->monthlyIncomeValue->setStyleSheet(errorStyle);
    ui->yearlyIncomeValue->setStyleSheet(errorStyle);
    ui->growthRateValue->setStyleSheet(errorStyle);
    ui->dailyIncomeChange->setStyleSheet(errorStyle);
    ui->monthlyIncomeChange->setStyleSheet(errorStyle);
    ui->yearlyIncomeChange->setStyleSheet(errorStyle);
    
    ui->updateTimeLabel->setText("更新时间: " + QDateTime::currentDateTime().toString("hh:mm:ss"));
}

// 样式管理方法实现
void financial_income_analytics::setActiveTabButton(QPushButton *activeBtn)
{
    // 定义选中状态的样式
    const QString activeStyle = 
        "background-color: #1a73e8;"
        "color: white;"
        "border: none;"
        "border-radius: 4px;"
        "padding: 6px 12px;"
        "margin: 2px;"
        "font-size: 12px;";
    
    // 定义未选中状态的样式
    const QString inactiveStyle = 
        "background-color: #f1f3f4;"
        "color: #5f6368;"
        "border: none;"
        "border-radius: 4px;"
        "padding: 6px 12px;"
        "margin: 2px;"
        "font-size: 12px;";
    
    // 所有Tab按钮列表
    QList<QPushButton*> allTabButtons = {
        ui->realtimeTabBtn, 
        ui->sourceTabBtn, 
        ui->trendTabBtn
    };
    
    // 重置所有按钮为未选中状态
    for (QPushButton *btn : allTabButtons) {
        btn->setStyleSheet(inactiveStyle);
        // 强制刷新样式
        btn->style()->unpolish(btn);
        btn->style()->polish(btn);
        btn->update();
    }
    
    // 设置被点击的按钮为选中状态
    if (activeBtn) {
        activeBtn->setStyleSheet(activeStyle);
        // 强制刷新样式
        activeBtn->style()->unpolish(activeBtn);
        activeBtn->style()->polish(activeBtn);
        activeBtn->update();
        
        qDebug() << "设置选中按钮:" << activeBtn->objectName();
    }
}

void financial_income_analytics::setMetricValue(QLabel *label, double value, const QString &prefix)
{
    label->setText(prefix + QString::number(value, 'f', 2));
}

void financial_income_analytics::setChangeValue(QLabel *label, double value)
{
    if (value >= 0) {
        label->setText("▲ " + QString::number(value, 'f', 2) + "%");
        label->setStyleSheet("color: #188038; font-weight: bold;");
    } else {
        label->setText("▼ " + QString::number(qAbs(value), 'f', 2) + "%");
        label->setStyleSheet("color: #d93025; font-weight: bold;");
    }
}

void financial_income_analytics::setupLabelStyles()
{
    // UI文件中已经正确设置了所有标签为32px高度
    // 这里只需要确保样式正确应用，无需重复设置高度
    QStringList labelNames = {
        "periodLabel", "startDateLabel", "endDateLabel",
        "modelLabel", "forecastPeriodLabel", "confidenceLabel"
    };
    
    for (const QString &labelName : labelNames) {
        QLabel *label = findChild<QLabel*>(labelName);
        if (label) {
            // 确保文本居中对齐
            label->setAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
            
            // 强制刷新样式，确保UI文件中的样式生效
            label->style()->unpolish(label);
            label->style()->polish(label);
            label->update();
            
            qDebug() << "刷新标签样式:" << labelName << "高度:" << label->height();
        } else {
            qDebug() << "未找到标签:" << labelName;
        }
    }
}

// 设置实时图表组件
void financial_income_analytics::setupRealtimeChart()
{
    // 1. 首先删除m_realtimeChart指针，避免内存泄漏
    if (m_realtimeChart) {
        delete m_realtimeChart;
        m_realtimeChart = nullptr;
    }
    
    // 2. 直接在realtimeChartWidget上工作，不使用嵌入方式
    ui->realtimeChartWidget->setObjectName("realtimeChartWidget");
    ui->realtimeChartWidget->setMinimumSize(QSize(0, 180));
    ui->realtimeChartWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    
    // 3. 清除realtimeChartWidget中所有现有的布局和子控件
    // 移除所有子控件
    while (QWidget *child = ui->realtimeChartWidget->findChild<QWidget*>()) {
        delete child;
    }
    
    // 移除任何现有的布局
    QLayout *layout = ui->realtimeChartWidget->layout();
    if (layout) {
        delete layout;
        ui->realtimeChartWidget->setLayout(nullptr);
    }
    
    // 4. 重新创建IncomeChartWidget，但直接设置父控件为realtimeChartWidget
    m_realtimeChart = new IncomeChartWidget(ui->realtimeChartWidget);
    m_realtimeChart->setGeometry(ui->realtimeChartWidget->rect()); // 确保图表填充整个容器
    
    // 5. 设置图表属性
    m_realtimeChart->setTitle("实时收入趋势图");
    m_realtimeChart->setAnimationEnabled(true);
    m_realtimeChart->setTimeRange(24);
    m_realtimeChart->setMaxDataPoints(50);
    
    // 6. 确保m_realtimeChart会自动填充父控件
    m_realtimeChart->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    
    // 7. 确保当realtimeChartWidget大小改变时，m_realtimeChart也会相应调整
    // 使用事件过滤器来监听大小变化
    ui->realtimeChartWidget->installEventFilter(this);
    
    // 8. 确保控件可见
    m_realtimeChart->show();
    ui->realtimeChartWidget->update();
    ui->realtimeChartWidget->show();
}

// 事件过滤器，用于处理realtimeChartWidget的大小变化
bool financial_income_analytics::eventFilter(QObject *watched, QEvent *event)
{
    // 检查是否是realtimeChartWidget的调整大小事件
    if (watched == ui->realtimeChartWidget && event->type() == QEvent::Resize)
    {
        // 当realtimeChartWidget大小改变时，调整m_realtimeChart的几何属性
        if (m_realtimeChart)
        {
            m_realtimeChart->setGeometry(ui->realtimeChartWidget->rect());
        }
    }
    
    // 继续传递事件给基类处理
    return QObject::eventFilter(watched, event);
}

// 图表时间范围下拉框索引变化处理
void financial_income_analytics::on_chartTimeRangeComboBox_currentIndexChanged(int index)
{
    // 根据索引设置不同的时间范围
    int timeRange = 24; // 默认24小时
    switch (index)
    {
    case 0: // 24小时
        timeRange = 24;
        break;
    case 1: // 7天
        timeRange = 168;
        break;
    case 2: // 30天
        timeRange = 720;
        break;
    default:
        break;
    }
    
    if (m_realtimeChart)
    {
        m_realtimeChart->setTimeRange(timeRange);
    }
}

// 图表刷新率下拉框索引变化处理
void financial_income_analytics::on_chartRefreshRateComboBox_currentIndexChanged(int index)
{
    // 这里可以根据需要实现刷新率调整逻辑
    // 例如，设置数据更新的定时器间隔
    int refreshRate = 5; // 默认5秒
    switch (index)
    {
    case 0: // 1秒
        refreshRate = 1;
        break;
    case 1: // 5秒
        refreshRate = 5;
        break;
    case 2: // 10秒
        refreshRate = 10;
        break;
    default:
        break;
    }
    
    // 这里可以添加定时器调整逻辑
    // 例如更新数据刷新定时器的间隔
}

// 更新实时图表数据
void financial_income_analytics::updateRealtimeChart(const QStringList &labels, const QList<double> &values)
{
    if (!m_realtimeChart) {
        qDebug() << "实时图表组件未初始化";
        return;
    }
    
    try {
        // 直接使用API返回的24小时数据更新图表
        m_realtimeChart->updateChart(labels, values);
        
        qDebug() << "实时图表更新成功，数据点数量:" << values.size();
        
    } catch (const std::exception& e) {
        qDebug() << "更新实时图表时发生异常:" << e.what();
    } catch (...) {
        qDebug() << "更新实时图表时发生未知异常";
    }
}

